home *** CD-ROM | disk | FTP | other *** search
/ IRIX Base Documentation 2002 November / SGI IRIX Base Documentation 2002 November.iso / usr / share / catman / p_man / cat3 / SCSL / sgemm.z / sgemm
Encoding:
Text File  |  2002-10-03  |  23.3 KB  |  463 lines

  1.  
  2.  
  3.  
  4. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  5.  
  6.  
  7.  
  8. NNNNAAAAMMMMEEEE
  9.      SSSSGGGGEEEEMMMMMMMM, DDDDGGGGEEEEMMMMMMMM, CCCCGGGGEEEEMMMMMMMM, ZZZZGGGGEEEEMMMMMMMM - Multiplies a real or complex general matrix
  10.      by a real or complex general matrix
  11.  
  12. SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
  13.      Single precision
  14.  
  15.           Fortran:
  16.  
  17.                CCCCAAAALLLLLLLL SSSSGGGGEEEEMMMMMMMM ((((_t_r_a_n_s_a,,,, _t_r_a_n_s_b,,,, _m,,,, _n,,,, _k,,,, _a_l_p_h_a,,,, _a,,,, _l_d_a,,,, _b,,,, _l_d_b,,,,
  18.                _b_e_t_a,,,, _c,,,, _l_d_c))))
  19.  
  20.           C/C++:
  21.                ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  22.                vvvvooooiiiidddd ssssggggeeeemmmmmmmm ((((cccchhhhaaaarrrr *_t_r_a_n_s_a,,,, cccchhhhaaaarrrr *_t_r_a_n_s_b,,,, iiiinnnntttt _m,,,, iiiinnnntttt _n,,,, iiiinnnntttt _k,,,,
  23.                ffffllllooooaaaatttt _a_l_p_h_a,,,, ffffllllooooaaaatttt *_a,,,, iiiinnnntttt _l_d_a,,,, ffffllllooooaaaatttt *_b,,,, iiiinnnntttt _l_d_b,,,, ffffllllooooaaaatttt _b_e_t_a,,,,
  24.                ffffllllooooaaaatttt *_c,,,, iiiinnnntttt _l_d_c))));;;;
  25.  
  26.      Double precision
  27.  
  28.           Fortran:
  29.                CCCCAAAALLLLLLLL DDDDGGGGEEEEMMMMMMMM ((((_t_r_a_n_s_a,,,, _t_r_a_n_s_b,,,, _m,,,, _n,,,, _k,,,, _a_l_p_h_a,,,, _a,,,, _l_d_a,,,, _b,,,, _l_d_b,,,,
  30.                _b_e_t_a,,,, _c,,,, _l_d_c))))
  31.  
  32.           C/C++:
  33.                ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  34.                vvvvooooiiiidddd ddddggggeeeemmmmmmmm ((((cccchhhhaaaarrrr *_t_r_a_n_s_a,,,, cccchhhhaaaarrrr *_t_r_a_n_s_b,,,, iiiinnnntttt _m,,,, iiiinnnntttt _n,,,, iiiinnnntttt _k,,,,
  35.                ddddoooouuuubbbblllleeee _a_l_p_h_a,,,, ddddoooouuuubbbblllleeee *_a,,,, iiiinnnntttt _l_d_a,,,, ddddoooouuuubbbblllleeee *_b,,,, iiiinnnntttt _l_d_b,,,, ddddoooouuuubbbblllleeee
  36.                _b_e_t_a,,,, ddddoooouuuubbbblllleeee *_c,,,, iiiinnnntttt _l_d_c);
  37.  
  38.      Single precision complex
  39.  
  40.           Fortran:
  41.  
  42.                CCCCAAAALLLLLLLL CCCCGGGGEEEEMMMMMMMM ((((_t_r_a_n_s_a,,,, _t_r_a_n_s_b,,,, _m,,,, _n,,,, _k,,,, _a_l_p_h_a,,,, _a,,,, _l_d_a,,,, _b,,,, _l_d_b,,,,
  43.                _b_e_t_a,,,, _c,,,, _l_d_c))))
  44.  
  45.           C/C++:
  46.                ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  47.                vvvvooooiiiidddd ccccggggeeeemmmmmmmm ((((cccchhhhaaaarrrr *_t_r_a_n_s_a,,,, cccchhhhaaaarrrr *_t_r_a_n_s_b,,,, iiiinnnntttt _m,,,, iiiinnnntttt _n,,,, iiiinnnntttt _k,,,,
  48.                ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_a_l_p_h_a,,,, ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_a,,,, iiiinnnntttt _l_d_a,,,, ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_b,,,,
  49.                iiiinnnntttt _l_d_b,,,, ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_b_e_t_a,,,, ssssccccssssllll____ccccoooommmmpppplllleeeexxxx *_c,,,, iiiinnnntttt llllddddcccc);
  50.  
  51.           C++ STL:
  52.                ####iiiinnnncccclllluuuuddddeeee <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>
  53.                ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  54.                vvvvooooiiiidddd ccccggggeeeemmmmmmmm ((((cccchhhhaaaarrrr *_t_r_a_n_s_a,,,, cccchhhhaaaarrrr *_t_r_a_n_s_b,,,, iiiinnnntttt _m,,,, iiiinnnntttt _n,,,, iiiinnnntttt _k,,,,
  55.                ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_a_l_p_h_a,,,, ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_a,,,, iiiinnnntttt _l_d_a,,,,
  56.                ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_b,,,, iiiinnnntttt _l_d_b,,,, ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_b_e_t_a,,,,
  57.                ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>> *_c,,,, iiiinnnntttt _l_d_c))));;;;
  58.  
  59.  
  60.  
  61.  
  62.  
  63.                                                                         PPPPaaaaggggeeee 1111
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  71.  
  72.  
  73.  
  74.      Double precision complex
  75.  
  76.           Fortran:
  77.                CCCCAAAALLLLLLLL ZZZZGGGGEEEEMMMMMMMM ((((_t_r_a_n_s_a,,,, _t_r_a_n_s_b,,,, _m,,,, _n,,,, _k,,,, _a_l_p_h_a,,,, _a,,,, _l_d_a,,,, _b,,,, _l_d_b,,,,
  78.                _b_e_t_a,,,, _c,,,, _l_d_c))))
  79.  
  80.           C/C++:
  81.                ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  82.                vvvvooooiiiidddd zzzzggggeeeemmmmmmmm ((((cccchhhhaaaarrrr *_t_r_a_n_s_a,,,, cccchhhhaaaarrrr *_t_r_a_n_s_b,,,, iiiinnnntttt _m,,,, iiiinnnntttt _n,,,, iiiinnnntttt _k,,,,
  83.                ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_a_l_p_h_a,,,, ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_a,,,, iiiinnnntttt _l_d_a,,,, ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_b,,,,
  84.                iiiinnnntttt _l_d_b,,,, ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_b_e_t_a,,,, ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx *_c,,,, iiiinnnntttt _l_d_c))));;;;
  85.  
  86.           C++ STL:
  87.                ####iiiinnnncccclllluuuuddddeeee <<<<ccccoooommmmpppplllleeeexxxx....hhhh>>>>
  88.                ####iiiinnnncccclllluuuuddddeeee <<<<ssssccccssssllll____bbbbllllaaaassss....hhhh>>>>
  89.                vvvvooooiiiidddd zzzzggggeeeemmmmmmmm ((((cccchhhhaaaarrrr *_t_r_a_n_s_a,,,, cccchhhhaaaarrrr *_t_r_a_n_s_b,,,, iiiinnnntttt _m,,,, iiiinnnntttt _n,,,, iiiinnnntttt _k,,,,
  90.                ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_a_l_p_h_a,,,, ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_a,,,, iiiinnnntttt _l_d_a,,,,
  91.                ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_b,,,, iiiinnnntttt _l_d_b,,,, ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_b_e_t_a,,,,
  92.                ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>> *_c,,,, iiiinnnntttt _l_d_c))));;;;
  93.  
  94. IIIIMMMMPPPPLLLLEEEEMMMMEEEENNNNTTTTAAAATTTTIIIIOOOONNNN
  95.      These routines are part of the SCSL Scientific Library and can be loaded
  96.      using either the ----llllssssccccssss or the ----llllssssccccssss____mmmmpppp option.  The ----llllssssccccssss____mmmmpppp option
  97.      directs the linker to use the multi-processor version of the library.
  98.  
  99.      When linking to SCSL with ----llllssssccccssss or ----llllssssccccssss____mmmmpppp, the default integer size is
  100.      4 bytes (32 bits). Another version of SCSL is available in which integers
  101.      are 8 bytes (64 bits).  This version allows the user access to larger
  102.      memory sizes and helps when porting legacy Cray codes.  It can be loaded
  103.      by using the ----llllssssccccssss____iiii8888 option or the ----llllssssccccssss____iiii8888____mmmmpppp option. A program may use
  104.      only one of the two versions; 4-byte integer and 8-byte integer library
  105.      calls cannot be mixed.
  106.  
  107.      The C and C++ prototypes shown above are appropriate for the 4-byte
  108.      integer version of SCSL. When using the 8-byte integer version, the
  109.      variables of type iiiinnnntttt become lllloooonnnngggg lllloooonnnngggg and the <<<<ssssccccssssllll____bbbbllllaaaassss____iiii8888....hhhh>>>> header
  110.      file should be included.
  111.  
  112. DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
  113.      SSSSGGGGEEEEMMMMMMMM and DDDDGGGGEEEEMMMMMMMM multiply a real general matrix by a real general matrix.
  114.  
  115.      CCCCGGGGEEEEMMMMMMMM and ZZZZGGGGEEEEMMMMMMMM  multiply a complex general matrix by a complex general
  116.      matrix.
  117.  
  118.      These routines perform one of the matrix-matrix operations:
  119.  
  120.           _C <- _a_l_p_h_a _o_p(_A) _o_p(_B) + _b_e_t_a _C
  121.  
  122.      where _o_p(_X) is one of the following:
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.                                                                         PPPPaaaaggggeeee 2222
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  137.  
  138.  
  139.  
  140.           _o_p(_X) = _X
  141.  
  142.           _o_p(_X) = _X_T
  143.  
  144.           _o_p(_X) = _X_H (CCCCGGGGEEEEMMMMMMMM and ZZZZGGGGEEEEMMMMMMMM only)
  145.  
  146.      where
  147.  
  148.      *   _a_l_p_h_a and _b_e_t_a are scalars
  149.  
  150.      *   _A, _B, and _C are matrices
  151.  
  152.      *   _o_p(_A) is an _m-by-_k matrix
  153.  
  154.      *   _o_p(_B) is a _k-by-_n matrix
  155.  
  156.      *   _C is an _m-by-_n matrix.
  157.  
  158.      *   _X _T  is the transpose of _x
  159.  
  160.      *   _X_H  is the conjugate transpose of _X.
  161.  
  162.      See the NOTES section of this man page for information about the
  163.      interpretation of the data types described in the following arguments.
  164.  
  165.      These routines have the following arguments:
  166.  
  167.      _t_r_a_n_s_a    Character.  (input)
  168.                Specifies the form of oooopppp((((AAAA)))) to be used in the matrix
  169.                multiplication, as follows:
  170.  
  171.                _t_r_a_n_s_a = 'N' or 'n': _o_p(_A) = _A
  172.  
  173.                _t_r_a_n_s_a = 'T' or 't': _o_p(_A) = _A _T
  174.  
  175.                _t_r_a_n_s_a = 'C' or 'c': _o_p(_A) = _A _T  (SSSSGGGGEEEEMMMMMMMM and DDDDGGGGEEEEMMMMMMMM), or _o_p(_A)
  176.                = _A_H  (CCCCGGGGEEEEMMMMMMMM and ZZZZGGGGEEEEMMMMMMMM)
  177.  
  178.                For C/C++, a pointer to this character is passed.
  179.  
  180.      _t_r_a_n_s_b    Character.  (input)
  181.                Specifies the form of _o_p(_B) to be used in the matrix
  182.                multiplication, as follows:
  183.  
  184.                _t_r_a_n_s_b = 'N' or 'n': _o_p(_B) = _B
  185.  
  186.                _t_r_a_n_s_b = 'T' or 't': _o_p(_B) = _B_T
  187.  
  188.                _t_r_a_n_s_b = 'C' or 'c': _o_p(_B) = _B_T (SSSSGGGGEEEEMMMMMMMM and DDDDGGGGEEEEMMMMMMMM), or _o_p(_B) =
  189.                _B_H (CCCCGGGGEEEEMMMMMMMM and ZZZZGGGGEEEEMMMMMMMM)
  190.  
  191.  
  192.  
  193.  
  194.  
  195.                                                                         PPPPaaaaggggeeee 3333
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  203.  
  204.  
  205.  
  206.                For C/C++, a pointer to this character is passed.
  207.  
  208.      _m         Integer.  (input)
  209.                Specifies the number of rows in matrix _o_p(_A) and in matrix _C.
  210.                _m must be >= 0.
  211.  
  212.      _n         Integer.  (input)
  213.                Specifies the number of columns in matrix _o_p(_B) and in matrix
  214.                _C.  _n must be >= 0.
  215.  
  216.      _k         Integer.  (input)
  217.                Specifies the number of columns of matrix _o_p(_A) and the number
  218.                of rows of matrix _o_p(_B).  _k must be >= 0.
  219.  
  220.      _a_l_p_h_a     First scalar factor.  (input)
  221.                SSSSGGGGEEEEMMMMMMMM: Single precision.
  222.                DDDDGGGGEEEEMMMMMMMM: Double precision.
  223.                CCCCGGGGEEEEMMMMMMMM: Single precision complex.
  224.                ZZZZGGGGEEEEMMMMMMMM: Double precision complex.
  225.  
  226.                For C/C++, a pointer to this scalar is passed when alpha is
  227.                complex; otherwise, alpha is passed by value.
  228.  
  229.      _a         Array of dimension (_l_d_a,_k_a).  (input)
  230.                SSSSGGGGEEEEMMMMMMMM: Single precision array.
  231.                DDDDGGGGEEEEMMMMMMMM: Double precision array.
  232.                CCCCGGGGEEEEMMMMMMMM: Single precision complex array.
  233.                ZZZZGGGGEEEEMMMMMMMM: Double precision complex array.
  234.                When _t_r_a_n_s_a = 'N' or 'n', _k_a is _k; otherwise, it is _m.
  235.                Contains the matrix _A.
  236.  
  237.                Before entry with _t_r_a_n_s_a = 'N' or 'n', the leading _m-by-_k part
  238.                of array _a must contain matrix _A; otherwise, the leading _k-by-_m
  239.                part of array _a must contain matrix _A.
  240.  
  241.      _l_d_a       Integer.  (input)
  242.                Specifies the first dimension of _a as declared in the calling
  243.                program.
  244.                When _t_r_a_n_s_a = 'N' or 'n', _l_d_a >= MMMMAAAAXXXX(1,_m); otherwise, _l_d_a >=
  245.                MMMMAAAAXXXX(1,_k).
  246.  
  247.      _b         Array of dimension (_l_d_b,_k_b).  (input)
  248.                SSSSGGGGEEEEMMMMMMMM: Single precision array.
  249.                DDDDGGGGEEEEMMMMMMMM: Double precision array.
  250.                CCCCGGGGEEEEMMMMMMMM: Single precision complex array.
  251.                ZZZZGGGGEEEEMMMMMMMM: Double precision complex array.
  252.                When _t_r_a_n_s_b = 'N' or 'n', _k_b is _n; otherwise, it is _k.
  253.                Contains the matrix _B.
  254.  
  255.                Before entry with _t_r_a_n_s_b = 'N' or 'n', the leading _k-by-_n part
  256.                of array _b must contain matrix _B; otherwise, the leading _n-by-_k
  257.                part of array _b must contain matrix _B.
  258.  
  259.  
  260.  
  261.                                                                         PPPPaaaaggggeeee 4444
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  269.  
  270.  
  271.  
  272.      _l_d_b       Integer.  (input)
  273.                Specifies the first dimension of _b as declared in the calling
  274.                program.  When _t_r_a_n_s_b = 'N' or 'n', _l_d_b >= MMMMAAAAXXXX(1,_k); otherwise,
  275.                _l_d_b >= MMMMAAAAXXXX(1,_n).
  276.  
  277.      _b_e_t_a      Scalar factor.  (input)
  278.                SSSSGGGGEEEEMMMMMMMM: Single precision.
  279.                DDDDGGGGEEEEMMMMMMMM: Double precision.
  280.                CCCCGGGGEEEEMMMMMMMM: Single precision complex.
  281.                ZZZZGGGGEEEEMMMMMMMM: Double precision complex.  When _b_e_t_a is supplied as 0, _c
  282.                need not be set on input.
  283.  
  284.                For C/C++, a pointer to this scalar is passed when beta is
  285.                complex; otherwise, beta is passed by value.
  286.  
  287.      _c         Array of dimension (_l_d_c,_n).  (input and output)
  288.                SSSSGGGGEEEEMMMMMMMM: Single precision array.
  289.                DDDDGGGGEEEEMMMMMMMM: Double precision array.
  290.                CCCCGGGGEEEEMMMMMMMM: Single precision complex array.
  291.                ZZZZGGGGEEEEMMMMMMMM: Double precision complex array.
  292.                Contains the matrix _C.
  293.  
  294.                Before entry, the leading _m-by-_n part of array _c must contain
  295.                matrix _C, except when _b_e_t_a is 0; in which case, _c need not be
  296.                set.  On exit, the _m-by-_n result matrix overwrites array _c.
  297.  
  298.      _l_d_c       Integer.  (input)
  299.  
  300.                Specifies the first dimension of _c as declared in the calling
  301.                program.  _l_d_c >= MMMMAAAAXXXX(1,_m).
  302.  
  303. NNNNOOOOTTTTEEEESSSS
  304.      These routines are Level 3 Basic Linear Algebra Subprograms (Level 3
  305.      BLAS).
  306.  
  307.    DDDDaaaattttaaaa TTTTyyyyppppeeeessss
  308.      The following data types are described in this documentation:
  309.  
  310.           TTTTeeeerrrrmmmm UUUUsssseeeedddd                     DDDDaaaattttaaaa ttttyyyyppppeeee
  311.  
  312.      Fortran:
  313.  
  314.           Array dimensioned _n           xxxx((((nnnn))))
  315.  
  316.           Array of dimensions (_m,_n)     xxxx((((mmmm,,,,nnnn))))
  317.  
  318.           Character                     CCCCHHHHAAAARRRRAAAACCCCTTTTEEEERRRR
  319.  
  320.           Integer                       IIIINNNNTTTTEEEEGGGGEEEERRRR (IIIINNNNTTTTEEEEGGGGEEEERRRR****8888 for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.                                                                         PPPPaaaaggggeeee 5555
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  335.  
  336.  
  337.  
  338.           Single precision              RRRREEEEAAAALLLL
  339.  
  340.           Double precision              DDDDOOOOUUUUBBBBLLLLEEEE PPPPRRRREEEECCCCIIIISSSSIIIIOOOONNNN
  341.  
  342.           Single precision complex      CCCCOOOOMMMMPPPPLLLLEEEEXXXX
  343.  
  344.           Double precision complex      DDDDOOOOUUUUBBBBLLLLEEEE CCCCOOOOMMMMPPPPLLLLEEEEXXXX
  345.  
  346.      C/C++:
  347.  
  348.           Array dimensioned _n           xxxx[[[[_n]]]]
  349.  
  350.           Array of dimensions (_m,_n)     xxxx[[[[mmmm****nnnn]]]]
  351.  
  352.           Character                     cccchhhhaaaarrrr
  353.  
  354.           Integer                       iiiinnnntttt (lllloooonnnngggg lllloooonnnngggg for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])
  355.  
  356.           Single precision              ffffllllooooaaaatttt
  357.  
  358.           Double precision              ddddoooouuuubbbblllleeee
  359.  
  360.           Single precision complex      ssssccccssssllll____ccccoooommmmpppplllleeeexxxx
  361.  
  362.           Double precision complex      ssssccccssssllll____zzzzoooommmmpppplllleeeexxxx
  363.  
  364.      C++ STL:
  365.  
  366.           Array dimensioned _n           xxxx[[[[_n]]]]
  367.  
  368.           Array of dimensions (_m,_n)     xxxx[[[[mmmm****nnnn]]]]
  369.  
  370.           Character                     cccchhhhaaaarrrr
  371.  
  372.           Integer                       iiiinnnntttt (lllloooonnnngggg lllloooonnnngggg for ----llllssssccccssss____iiii8888[[[[____mmmmpppp]]]])
  373.  
  374.           Single precision              ffffllllooooaaaatttt
  375.  
  376.           Double precision              ddddoooouuuubbbblllleeee
  377.  
  378.           Single precision complex      ccccoooommmmpppplllleeeexxxx<<<<ffffllllooooaaaatttt>>>>
  379.  
  380.           Double precision complex      ccccoooommmmpppplllleeeexxxx<<<<ddddoooouuuubbbblllleeee>>>>
  381.  
  382.      Note that you can explicitly declare multidimensional C/C++ arrays
  383.      provided that the array dimensions are swapped with respect to the
  384.      Fortran declaration (e.g., xxxx[[[[nnnn]]]][[[[mmmm]]]] in C/C++ versus xxxx((((mmmm,,,,nnnn)))) in Fortran).
  385.      To avoid a compiler type mismatch error in C++ (or a compiler warning
  386.      message in C), however, the array should be cast to a pointer of the
  387.      appropriate type when passed as an argument to a SCSL routine.
  388.  
  389.  
  390.  
  391.  
  392.  
  393.                                                                         PPPPaaaaggggeeee 6666
  394.  
  395.  
  396.  
  397.  
  398.  
  399.  
  400. SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))                                                            SSSSGGGGEEEEMMMMMMMM((((3333SSSS))))
  401.  
  402.  
  403.  
  404. SSSSEEEEEEEE AAAALLLLSSSSOOOO
  405.      DDDDGGGGEEEEMMMMMMMMSSSS(3S) to multiply general matrices by using Strassen's algorithm
  406.  
  407.      IIIINNNNTTTTRRRROOOO____SSSSCCCCSSSSLLLL(3S), IIIINNNNTTTTRRRROOOO____BBBBLLLLAAAASSSS3333(3S)
  408.  
  409.      IIIINNNNTTTTRRRROOOO____CCCCBBBBLLLLAAAASSSS(3S) for information about using the C interface to Fortran 77
  410.      Basic Linear Algebra Subprograms (legacy BLAS) set forth by the Basic
  411.      Linear Algebra Subprograms Technical Forum.
  412.  
  413.  
  414.  
  415.  
  416.  
  417.  
  418.  
  419.  
  420.  
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436.  
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456.                                                                         PPPPaaaaggggeeee 7777
  457.  
  458.  
  459.  
  460.  
  461.  
  462.  
  463.